package com.sparrow.event.model;

import com.sparrow.common.thread.executor.EventExecutor;

import java.util.concurrent.Executor;
import java.util.function.IntSupplier;
import java.util.function.Supplier;

/**
 * 该类用于包装事件，包含事件的相关属性和配置构建器。
 */
public class Event {

    // 事件关联的对象
    private Object obj;
    // 标识事件是否为同步执行
    private boolean sync;
    // 事件的分发代码
    private long dispatchCode;
    // 事件执行器
    private Executor executor;
    // 接收事件时直接执行的逻辑
    private Runnable directRun;
    // 设置event invoker 执行参数
    private Object[] args;

    /**
     * 创建一个新的事件构建器实例。
     *
     * @param obj 事件关联的对象
     * @return 事件构建器实例
     */
    public static Builder newBuilder(Object obj) {
        Event event = new Event();
        event.obj = obj;
        return event.new Builder();
    }

    public Object[] getArgs() {
        return args;
    }

    /**
     * 获取事件关联的对象。
     *
     * @return 事件关联的对象
     */
    public Object getObj() {
        return obj;
    }

    /**
     * 判断事件是否为同步执行。
     *
     * @return 如果是同步执行返回 true，否则返回 false
     */
    public boolean isSync() {
        return sync;
    }

    /**
     * 判断事件是否为异步执行。
     *
     * @return 如果是异步执行返回 true，否则返回 false
     */
    public boolean isAsync() {
        return!sync;
    }

    /**
     * 获取事件执行器。
     *
     * @return 事件执行器
     */
    public Executor getExecutor() {
        return executor;
    }

    /**
     * 获取事件的分发代码。
     *
     * @return 事件的分发代码
     */
    public long getDispatchCode() {
        return dispatchCode;
    }

    /**
     * 获取接收事件时直接执行的逻辑。
     *
     * @return 直接执行的逻辑
     */
    public Runnable getDirectRun() {
        return directRun;
    }

    public Object[] buildArgs() {
        return new Object[] {getObj()};
    }

    /**
     * 事件构建器类，用于配置事件的属性。
     */
    public class Builder {

        /**
         * 将事件配置为同步执行。
         *
         * @return 当前构建器实例
         */
        public Builder sync() {
            Event.this.sync = true;
            return this;
        }

        /**
         * 将事件配置为异步执行。
         *
         * @return 当前构建器实例
         */
        public Builder async() {
            Event.this.sync = false;
            return this;
        }

        /**
         * 设置事件的分发代码。
         *
         * @param code 分发代码
         * @return 当前构建器实例
         */
        public Builder dispatchCode(long code) {
            Event.this.dispatchCode = code;
            return this;
        }

        /**
         * 设置事件执行器。
         *
         * @param executor 事件执行器
         * @return 当前构建器实例
         */
        public Builder executor(Executor executor) {
            Event.this.executor = executor;
            return this;
        }

        /**
         * 设置接收事件时直接执行的逻辑。
         *
         * @param run 直接执行的逻辑
         * @return 当前构建器实例
         */
        public Builder directRun(Runnable run) {
            Event.this.directRun = run;
            return this;
        }

        /**
         * 构建事件实例。
         *
         * @return 构建好的事件实例
         */
        public Event build() {
            if (args == null) {
                args = buildArgs();
            }
            return Event.this;
        }

        public Builder args(Object[] args) {
            Event.this.args = args;
            return this;
        }
    }
}